package com.cf.r1042_ak;

import java.io.*;
import java.util.Arrays;
import java.util.HashSet;
import java.util.PriorityQueue;

public class g {

    static int MOD = 1000000007;

    // 递归函数：处理值 v（代表原始 s = v+1），并且只消耗最多 k 次操作，返回对应乘积
    static long dfs(long v, long k, long[] dp) {
        if (k == 0) return 1L;
        long ans = (v + 1) % MOD;     // 第一次弹出的就是 v+1（对应原始 s）
        // 接下来我们可以在 v-1 的范围内按二进制分块继续处理，但我们只需要考虑到 30 位
        long vv = Math.min(v - 1, 30L);
        k -= 1; // 已经消费一次（弹出了 v+1）
        if (k == 0 || vv < 0) return ans % MOD;

        for (int j = 0; j <= vv; j++) {
            long block = 1L << j; // 2^j，安全因为 j <= 30
            if (k >= block) {
                // 可以完整消耗这个 2^j 大小的块，直接乘上预处理的 dp[j]
                ans = (ans * dp[j]) % MOD;
                k -= block;
            } else {
                // 不能完整消耗，递归到更小的级别
                ans = (ans * dfs(j, k, dp)) % MOD;
                k = 0;
                break;
            }
            if (k == 0) break;
        }
        return ans % MOD;
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(br);
        PrintWriter out = new PrintWriter(System.out);
        in.nextToken();

        // 预处理 dp[0..30]（与教程一致）
        long[] dp = new long[31];
        dp[0] = 1L;
        for (int i = 1; i <= 30; i++) {
            long cur = (i + 1);
            for (int j = 0; j < i; j++) {
                cur = (cur * dp[j]) % MOD;
            }
            dp[i] = cur % MOD;
        }
        int T = (int) in.nval;

        while (T-- > 0) {
            in.nextToken(); int n = (int) in.nval;
            in.nextToken(); int k = (int) in.nval;
            long[] s = new long[n];
            for (int i = 0; i < n; i++) {
                in.nextToken();
                s[i] = (long) in.nval;
                s[i]--;
            }
            Arrays.sort(s);

            long ans = 1L;
            boolean finished = false;
            for (int i = 0; i < n; i++) {
                long v = s[i];
                if (v <= 30 && k >= (1L << v)) {
                    k -= (1L << v);
                    ans = (ans * dp[(int) v]) % MOD;
                } else {
                    ans = (ans * dfs(v, k, dp)) % MOD;
                    finished = true;
                    break;
                }
                if (k == 0) { finished = true; break; }
            }
            out.println(ans);
        }
        out.flush();
        out.close();
        br.close();
    }

}